{% load static %}
Sound Classification using temporal augmentation and Mel frequency cepstral coefficients
# System and os level library imports
import time
import sys
import os
# array handling library imports
import pandas as pd
import numpy as np
# Sound processing library imports
import librosa
import librosa.display as display
# plotting library imports
import matplotlib.pyplot as plt
%matplotlib inline
# play sound in jupyter notebook
import IPython.display as ipd
# save the entities for futur use
import pickle
# Model building related libraries
import sklearn
from sklearn import metrics
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import LabelEncoder
# Deep learning library import
import keras.backend as K
from keras.utils import np_utils
from keras.models import model_from_json
from keras.utils import to_categorical
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten,BatchNormalization,Convolution2D, MaxPooling2D,Bidirectional, LSTM,SimpleRNN
from keras.callbacks import EarlyStopping, ModelCheckpoint, TensorBoard
from keras.optimizers import Adam
def saveModel(model_obj,model_file_name, weights_file_name = None):
"""Save keras model to disk."""
if weights_file_name is None:
weights_file_name = model_file_name
model_json = model_obj.to_json()
with open("new_models/{}.json".format(model_file_name), "w") as json_file:
json_file.write(model_json)
# serialize weights to HDF5
model_obj.save_weights("new_models/{}.h5".format(weights_file_name))
print("Saved model {} to disk".format(model_file_name))
def loadModel(model_file_name, weights_file_name = None):
"""Load keras model from disk."""
if weights_file_name is None:
weights_file_name = model_file_name
# load json and create model
json_file = open('./new_models/{}.json'.format(model_file_name), 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
# load weights into new model
loaded_model.load_weights("./new_models/{}.h5".format(weights_file_name))
print("Loaded model {} from disk".format(model_file_name))
return loaded_model
def get_predicted_classes(model_obj, val_data, test_data= None):
"""Function to return predicted classes."""
val_preds = model_obj.predict_classes(val_data)
if test_data is not None:
test_preds = model_obj.predict_classes(test_data)
return (val_preds, test_preds)
return val_preds
def get_predicted_class_prob(model_obj, val_data, test_data= None):
"""Function to return predicted class probabilities."""
val_preds = pd.DataFrame(model_obj.predict_proba(val_data))
if test_data is not None:
test_preds = pd.DataFrame(model_obj.predict_proba(test_data))
return (val_preds, test_preds)
return val_preds
def print_metrics(model_obj, train_x, train_y, test_x, test_y):
"""Function to print the model metrics."""
print(model_obj.metrics_names)
print(model_obj.evaluate(train_x, train_y))
print(model_obj.evaluate(test_x, test_y))
train_preds = model_obj.predict_classes(train_x)
test_preds = model_obj.predict_classes(test_x)
target_names = lb.classes_
return (pd.DataFrame(classification_report(y_pred=test_preds,
y_true=test_y.argmax(axis=1),
target_names = target_names,
output_dict = True
)))
os.getcwd()
path = "/home/bglrgpuaccess/BnglrMisc/Mahidhar/Music/augmented_genres/"
data_info = {}
for genre in os.listdir(path):
f = os.listdir(path+'/'+str(genre))
data_info[genre]=len(f)
data_info
ipd.Audio('/home/bglrgpuaccess/BnglrMisc/Mahidhar/Music/augmented_genres/blues/blues.00000.au_original.wav') # load a local WAV file
d,sr = librosa.load('/home/bglrgpuaccess/BnglrMisc/Mahidhar/Music/augmented_genres/blues/blues.00000.au_original.wav') # load a local WAV file
plt.axis('off')
plt.style.use('ggplot')
plt.style.use(['dark_background'])
plt.figure(figsize=(14, 5),)
librosa.display.waveplot(d, sr=sr,color='r',)
X - time y - amplitude
X = librosa.stft(d)
Xdb = librosa.amplitude_to_db(abs(X))
plt.figure(figsize=(14, 5))
librosa.display.specshow(Xdb, sr=sr, x_axis='time', y_axis='hz')
plt.title(" of the sample song")
plt.colorbar()
plt.show()
librosa.display.specshow(Xdb, sr=sr, x_axis='time', y_axis='log')
plt.title("Log transormed frequency")
plt.colorbar()
plt.show()
The zero crossing rate is the rate of sign-changes along a signal, i.e., the rate at which the signal changes from positive to negative or back.
np.sum(librosa.feature.zero_crossing_rate(d))
It indicates where the centre of mass for a sound is located and is calculated as the weighted mean of the frequencies present in the sound.
Consider two songs, one from a blues genre and the other belonging to metal. Now as compared to the blues genre song which is the same throughout its length, the metal song has more frequencies towards the end. So spectral centroid for blues song will lie somewhere near the middle of its spectrum while that for a metal song would be towards its end.
# Normalising the spectral centroid for visualisation
def normalize(d, axis=0):
"""This function will scale the features along the time axis by default."""
return sklearn.preprocessing.minmax_scale(d, axis=axis)
def plot_spectral_centroid(d,genre):
"""Function to plot the spectral centroid."""
spectral_centroids = librosa.feature.spectral_centroid(d, sr=sr)[0]
# Computing the time variable for visualization
frames = range(len(spectral_centroids))
t = librosa.frames_to_time(frames)
#Plotting the Spectral Centroid along the waveform
fig, ax = plt.subplots( nrows=1, ncols=1 )
librosa.display.waveplot(d, sr=sr, alpha=0.4)
plt.plot(t, normalize(spectral_centroids), color='r')
plt.title("Spectral Centroid of a {} song".format(genre))
plt.axhline(y=0.5, color='black', linestyle='--')
fig.set_size_inches(9.25, 4.5)
fig.savefig('img/{}_spectral_centroid.png'.format(genre))
plt.show()
for k in data_info.keys():
data_path = '/home/bglrgpuaccess/BnglrMisc/Mahidhar/Music/augmented_genres/{}/{}.00000.au_original.wav'.format(k,k)
d,sr = librosa.load(data_path)
plot_spectral_centroid(d,k)
It is a measure of the shape of the signal. It represents the frequency below which a specified percentage of the total spectral energy, e.g. 85%, lies.
def plot_spectral_rolloff(d,genre):
"""Function to plot the spectral roll off."""
#Plotting the Spectral Rolloff along the waveform
fig, ax = plt.subplots( nrows=1, ncols=1 )
spectral_rolloff = librosa.feature.spectral_rolloff(d+0.01, sr=sr)[0]
librosa.display.waveplot(d, sr=sr, alpha=0.4)
frames = range(len(spectral_rolloff))
t = librosa.frames_to_time(frames)
plt.plot(t, normalize(spectral_rolloff), color='r')
plt.title("Spectral Rolloff of a {} song".format(genre))
plt.axhline(y=0.5, color='black', linestyle='--')
fig.set_size_inches(9.25, 4.5)
fig.savefig('img/{}_spectral_rolloff.png'.format(genre))
plt.show()
for k in data_info.keys():
data_path = '/home/bglrgpuaccess/BnglrMisc/Mahidhar/Music/augmented_genres/{}/{}.00000.au_original.wav'.format(k,k)
d,sr = librosa.load(data_path)
plot_spectral_rolloff(d,k)
The Mel frequency cepstral coefficients (MFCCs) of a signal are a small set of features (usually about 10–20) which concisely describe the overall shape of a spectral envelope. It models the characteristics of the human voice.
def plot_mfcc(d,genre):
"""Function to plot the mfcc."""
fig, ax = plt.subplots( nrows=1, ncols=1 )
mfccs = librosa.feature.mfcc(d)
librosa.display.specshow(mfccs, sr=sr, x_axis='time')
fig.savefig('img/{}_mfcc.png'.format(genre))
plt.show()
return mfccs
for k in data_info.keys():
data_path = '/home/bglrgpuaccess/BnglrMisc/Mahidhar/Music/augmented_genres/{}/{}.00000.au_original.wav'.format(k,k)
d,sr = librosa.load(data_path)
mfccs = plot_mfcc(d,k)
mfccs = sklearn.preprocessing.scale(mfccs, axis=1)
plt.figure(figsize=(15, 5))
librosa.display.specshow(mfccs, sr=sr, x_axis='time')
Chroma features are an interesting and powerful representation for music audio in which the entire spectrum is projected onto 12 bins representing the 12 distinct semitones (or chroma) of the musical octave.
hop_length = 512
chromagram = librosa.feature.chroma_stft(d, sr=sr, hop_length=hop_length)
plt.figure(figsize=(15, 5))
librosa.display.specshow(chromagram, x_axis='time', y_axis='chroma', hop_length=hop_length, cmap='coolwarm')
def extract_features(y,sr):
"""This function extracts the features from songs,
We are extracting the Chroma features, spectral centroid, spectral bandwidth, spectral roll off, zero crossing rate and the mfccc's"""
chroma_freq = librosa.feature.chroma_stft(y=y, sr=sr)
specral_centroid = librosa.feature.spectral_centroid(y=y, sr=sr)
spectral_bandwidth = librosa.feature.spectral_bandwidth(y=y, sr=sr)
spectral_rolloff = librosa.feature.spectral_rolloff(y=y, sr=sr)
zero_crossing_rate = librosa.feature.zero_crossing_rate(y)
mfcc = np.mean(librosa.feature.mfcc(y=y, sr=sr,n_mfcc=39).T,axis = 0)
chroma_freq_arr = np.mean(np.ndarray.flatten(chroma_freq))
spectral_centroid_arr = np.mean(np.ndarray.flatten(specral_centroid))
spectral_bandwidth_arr = np.mean(np.ndarray.flatten(spectral_bandwidth))
spectral_rolloff_arr = np.mean(np.ndarray.flatten(spectral_rolloff))
zero_crossing_rate_arr = np.mean(np.ndarray.flatten(zero_crossing_rate))
mfcc_arr = np.ndarray.flatten(mfcc)
temp = np.array([chroma_freq_arr,spectral_centroid_arr,spectral_bandwidth_arr,spectral_rolloff_arr,zero_crossing_rate_arr])
all_features = np.concatenate([temp,mfcc_arr])
return all_features
def loadAudioDataExtractFeatures(file_ID,genre, file_format = 'wav'):
"""Load song and extract the features using the extract_features function"""
data_path = '/home/bglrgpuaccess/BnglrMisc/Mahidhar/Music/augmented_genres/{}/{}.wav'.format(genre,file_ID)
y,sr = librosa.load(data_path)
features = extract_features(y,sr)
return features
# X = []
# y= []
# for genre in os.listdir(path):
# print("genre",genre)
# path_genre = path+'/'+str(genre)
# for i in os.listdir(path_genre):
# if i.endswith('wav'):
# file_ID = i.strip('.wav') #file format already provided
# X.append(loadAudioDataExtractFeatures(genre= genre,file_ID=file_ID))
# y.append(genre)
# print("genre ended",genre)
# np.save('X_train_many_features.npy', np.array(X))
X = np.load('X_train_many_features.npy')
# np.save('y_train_many_features.npy', np.array(y))
y = np.load('y_train_many_features.npy')
X = np.array(X)
y = np.array(y)
lb = LabelEncoder()
y = to_categorical(lb.fit_transform(y))
pickle.dump(lb, open("label_encoder.pkl","wb"), protocol=pickle.HIGHEST_PROTOCOL)
num_labels = y.shape[1]
def recall(y_true, y_pred):
"""Recall metric.
Only computes a batch-wise average of recall.
Computes the recall, a metric for multi-label classification of
how many relevant items are selected.
"""
true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
recall = true_positives / (possible_positives + K.epsilon())
return recall
x_train, x_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 124)
scaler = StandardScaler()
scaler.fit(np.array(x_train[:, :-1], dtype = float))
x_train= scaler.transform(np.array(x_train[:, :-1], dtype = float))
x_test = scaler.transform(np.array(x_test[:, :-1], dtype = float))
pickle.dump(scaler, open("scaler.pkl","wb"), protocol=pickle.HIGHEST_PROTOCOL)
# with open('scaler.pkl', 'rb') as pickle_file:
# tep = pickle.load(pickle_file)
scaler.mean_
model_name = 'Basic_NN'
tb = TensorBoard(log_dir='./log/{}'.format(model_name), histogram_freq=0,
write_graph=True, write_images=True)
callbacks = [EarlyStopping(monitor='val_loss', min_delta= 0.005, patience=50),
EarlyStopping(monitor='val_acc', min_delta= 0.005, patience=50),
EarlyStopping(monitor='val_recall', min_delta= 0.005, patience=50),tb]
model_basic_nn = Sequential()
input_shape = x_train.shape[1]
num_labels = 10
model_basic_nn.add(Dense(256, input_shape=(input_shape,)))
model_basic_nn.add(Activation('relu'))
model_basic_nn.add(Dense(128))
model_basic_nn.add(Activation('relu'))
model_basic_nn.add(Dense(num_labels))
model_basic_nn.add(Activation('softmax'))
model_basic_nn.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['acc',recall])
model_basic_nn.summary()
%time model_basic_nn.fit(x_train, y_train, callbacks = callbacks,epochs=15000, validation_split=0.25)
model_basic_nn.metrics_names
model_basic_nn.evaluate(x_train, y_train)
train_preds_basic_nn = model_basic_nn.predict_classes(x_train)
test_preds_basic_nn = model_basic_nn.predict_classes(x_test)
train_preds_basic_nn_proba,test_preds_basic_nn_proba = get_predicted_class_prob(model_basic_nn,x_train, x_test)
train_preds_basic_nn,test_preds_basic_nn = get_predicted_classes(model_basic_nn,x_train, x_test)
saveModel(model_basic_nn,"model_basic_nn")
model_basic_nn = loadModel('model_basic_nn')
model_basic_nn.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['acc',recall])
x_train[0]
model_basic_nn_df = print_metrics(model_basic_nn,x_train,y_train, x_test, y_test)
model_basic_nn_df
model_basic_nn_df.to_csv("model_basic_nn_df.csv",index=True)
x_rnn_train = x_train.reshape(x_train.shape[0], 1, x_train.shape[1])
x_rnn_test = x_test.reshape(x_test.shape[0], 1, x_test.shape[1])
x_rnn_train.shape
model_name = 'Basic_RNN'
tb = TensorBoard(log_dir='./log/{}'.format(model_name), histogram_freq=0,
write_graph=True, write_images=True)
callbacks = [EarlyStopping(monitor='val_loss', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_acc', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_recall', min_delta= 0.005, patience=20),tb]
model_basic_rnn = Sequential()
model_basic_rnn.add(SimpleRNN(256 , input_shape=(x_rnn_train.shape[1], x_rnn_train.shape[2])))
model_basic_rnn.add(Dense(256))
model_basic_rnn.add(Activation('relu'))
model_basic_rnn.add(Dropout(0.5))
model_basic_rnn.add(Dense(256))
model_basic_rnn.add(Activation('relu'))
model_basic_rnn.add(Dropout(0.5))
model_basic_rnn.add(Dense(num_labels))
model_basic_rnn.add(Activation('softmax'))
model_basic_rnn.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['acc',recall])
model_basic_rnn.summary()
%time model_basic_rnn.fit(x_rnn_train, y_train, callbacks = callbacks,epochs=15000, validation_split=0.25)
train_preds_basic_rnn_proba,test_preds_basic_rnn_proba = get_predicted_class_prob(model_basic_rnn,x_rnn_train, x_rnn_test)
train_preds_basic_rnn,test_preds_basic_rnn = get_predicted_classes(model_basic_rnn,x_rnn_train, x_rnn_test)
model_basic_rnn_df = print_metrics(model_basic_rnn,x_rnn_train,y_train,x_rnn_test,y_test )
model_basic_rnn_df
saveModel(model_basic_rnn,"model_basic_RNN")
model_basic_rnn_df.to_csv("model_basic_rnn_df.csv")
model_name = 'Basic_LSTM'
tb = TensorBoard(log_dir='./log/{}'.format(model_name), histogram_freq=0,
write_graph=True, write_images=True)
callbacks = [EarlyStopping(monitor='val_loss', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_acc', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_recall', min_delta= 0.005, patience=20),tb]
model_lstm = Sequential()
model_lstm.add(LSTM(256 , input_shape=(x_rnn_train.shape[1], x_rnn_train.shape[2])))
model_lstm.add(BatchNormalization())
model_lstm.add(Dense(256))
model_lstm.add(Activation('relu'))
model_lstm.add(Dropout(0.5))
model_lstm.add(Dense(256))
model_lstm.add(Activation('relu'))
model_lstm.add(Dropout(0.5))
model_lstm.add(Dense(256))
model_lstm.add(Activation('relu'))
model_lstm.add(Dropout(0.5))
model_lstm.add(Dense(num_labels))
model_lstm.add(Activation('softmax'))
model_lstm.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['acc',recall])
model_lstm.summary()
%time model_lstm.fit(x_rnn_train, y_train, callbacks = callbacks,epochs=15000, validation_split=0.25)
train_preds_basic_lstm_proba,test_preds_basic_lstm_proba = get_predicted_class_prob(model_lstm,x_rnn_train, x_rnn_test)
train_preds_basic_lstm,test_preds_basic_lstm = get_predicted_classes(model_lstm,x_rnn_train, x_rnn_test)
model_lstm_df = print_metrics(model_lstm,x_rnn_train,y_train, x_rnn_test, y_test)
model_lstm_df
saveModel(model_lstm, 'Basic_LSTM')
model_lstm_df.to_csv("model_lstm_df.csv")
model_name = 'Bidirectional_LSTM'
tb = TensorBoard(log_dir='./log/{}'.format(model_name), histogram_freq=0,
write_graph=True, write_images=True)
callbacks = [EarlyStopping(monitor='val_loss', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_acc', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_recall', min_delta= 0.005, patience=20),tb]
model_bidi_lstm = Sequential()
model_bidi_lstm.add(Bidirectional(LSTM(256 ,return_sequences=True),
input_shape=(x_rnn_train.shape[1], x_rnn_train.shape[2])))
model_bidi_lstm.add(Bidirectional(LSTM(100)))
model_bidi_lstm.add(Dense(256))
model_bidi_lstm.add(Activation('relu'))
model_bidi_lstm.add(Dropout(0.5))
model_bidi_lstm.add(Dense(256))
model_bidi_lstm.add(Activation('relu'))
model_bidi_lstm.add(Dropout(0.5))
model_bidi_lstm.add(Dense(num_labels))
model_bidi_lstm.add(Activation('softmax'))
model_bidi_lstm.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['acc',recall])
model_bidi_lstm.summary()
%time model_bidi_lstm.fit(x_rnn_train, y_train, callbacks = callbacks,epochs=15000, validation_split=0.25,batch_size=30)
model_bidi_lstm.summary()
train_preds_basic_bidi_lstm_proba,test_preds_basic_bidi_lstm_proba = get_predicted_class_prob(model_bidi_lstm,x_rnn_train, x_rnn_test)
train_preds_basic_bidi_lstm,test_preds_basic_bidi_lstm = get_predicted_classes(model_bidi_lstm,x_rnn_train, x_rnn_test)
model_bidi_lstm_df = print_metrics(model_bidi_lstm,x_rnn_train,y_train,x_rnn_test,y_test )
model_bidi_lstm_df
saveModel(model_bidi_lstm,'Bidirectional_LSTM_basic')
model_bidi_lstm_df.to_csv("model_bidi_lstm_df.csv")
model_name = 'New_LSTM'
tb = TensorBoard(log_dir='./log/{}'.format(model_name), histogram_freq=0,
write_graph=True, write_images=True)
callbacks = [EarlyStopping(monitor='val_loss', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_acc', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_recall', min_delta= 0.005, patience=20),tb]
model_lstm2 = Sequential()
model_lstm2.add(LSTM(units=128, dropout=0.05, recurrent_dropout=0.35, return_sequences=True, input_shape=(x_rnn_train.shape[1], x_rnn_train.shape[2])))
model_lstm2.add(LSTM(units=32, dropout=0.05, recurrent_dropout=0.35, return_sequences=False))
model_lstm2.add(Dense(units=num_labels, activation='softmax'))
model_lstm2.add(Dropout(0.5))
model_lstm2.compile(loss='categorical_crossentropy', optimizer=Adam(), metrics=['accuracy',recall])
model_bidi_lstm2.summary()
%time model_lstm2.fit(x_rnn_train, y_train, callbacks = callbacks, batch_size=50, epochs=400, validation_split=0.25)
train_preds_basic_lstm2_proba,test_preds_basic_lstm2_proba = get_predicted_class_prob(model_lstm2,x_rnn_train, x_rnn_test)
train_preds_basic_lstm2,test_preds_basic_lstm2 = get_predicted_classes(model_lstm2,x_rnn_train, x_rnn_test)
model_lstm2_df = print_metrics(model_lstm2,x_rnn_train,y_train,x_rnn_test,y_test )
model_lstm2_df
saveModel(model_lstm2,"model_lstm2")
model_lstm2_df.to_csv("model_lstm2_df.csv")
model_name = 'New_Bidirectional_LSTM-1'
tb = TensorBoard(log_dir='./log/{}'.format(model_name), histogram_freq=0,
write_graph=True, write_images=True)
callbacks = [EarlyStopping(monitor='val_loss', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_acc', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_recall', min_delta= 0.005, patience=20),tb]
model_bidi_lstm2 = Sequential()
model_bidi_lstm2.add(Bidirectional(LSTM(128 ,return_sequences=True),
input_shape=(x_rnn_train.shape[1], x_rnn_train.shape[2])))
model_bidi_lstm2.add(Bidirectional(LSTM(100)))
model_bidi_lstm2.add(Dense(14))
model_bidi_lstm2.add(Activation('relu'))
model_bidi_lstm2.add(Dropout(0.5))
model_bidi_lstm2.add(Dense(num_labels))
model_bidi_lstm2.add(Activation('softmax'))
model_bidi_lstm2.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['acc',recall])
model_bidi_lstm2.summary()
%time model_bidi_lstm2.fit(x_rnn_train, y_train, callbacks = callbacks,epochs=15000, validation_split=0.25,batch_size=30)
model_bidi_lstm2.summary()
train_preds_bidi_lstm2_proba,test_preds_bidi_lstm2_proba = get_predicted_class_prob(model_bidi_lstm2,x_rnn_train, x_rnn_test)
train_preds_bidi_lstm2,test_preds_bidi_lstm2 = get_predicted_classes(model_bidi_lstm2,x_rnn_train, x_rnn_test)
model_bidi_lstm2_df = print_metrics(model_bidi_lstm2,x_rnn_train,y_train,x_rnn_test,y_test )
model_bidi_lstm2_df
saveModel(model_bidi_lstm2,"model_bidi_lstm2")
model_bidi_lstm2_df.to_csv("model_bidi_lstm2_df.csv")
(train_preds_basic_nn_proba.shape) == (train_preds_basic_rnn_proba.shape) == (train_preds_basic_lstm_proba.shape) == (train_preds_basic_bidi_lstm_proba.shape) == (train_preds_basic_lstm2_proba.shape) == (train_preds_bidi_lstm2_proba.shape)
(test_preds_basic_nn_proba.shape) == (test_preds_basic_rnn_proba.shape) == (test_preds_basic_lstm_proba.shape) == (test_preds_basic_bidi_lstm_proba.shape) == (test_preds_basic_lstm2_proba.shape) == (test_preds_bidi_lstm2_proba.shape)
train_proba_lists =[train_preds_basic_nn_proba, train_preds_basic_rnn_proba,train_preds_basic_lstm_proba,train_preds_basic_bidi_lstm_proba,train_preds_basic_lstm2_proba,train_preds_bidi_lstm2_proba]
test_proba_lists =[test_preds_basic_nn_proba, test_preds_basic_rnn_proba,test_preds_basic_lstm_proba,test_preds_basic_bidi_lstm_proba,test_preds_basic_lstm2_proba,test_preds_bidi_lstm2_proba]
train_ensem_proba = pd.concat([i for i in train_proba_lists],axis = 1)
test_ensem_proba = pd.concat([i for i in test_proba_lists],axis = 1)
model_name = 'Ensemble_NN'
tb = TensorBoard(log_dir='./log/{}'.format(model_name), histogram_freq=0,
write_graph=True, write_images=True)
callbacks = [EarlyStopping(monitor='val_loss', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_acc', min_delta= 0.005, patience=20),
EarlyStopping(monitor='val_recall', min_delta= 0.005, patience=20),tb]
model_ensemble_nn = Sequential()
model_ensemble_nn.add(Dense(128, input_shape=(train_ensem_proba.shape[1],)))
model_ensemble_nn.add(Activation('relu'))
model_ensemble_nn.add(Dropout(0.5))
model_ensemble_nn.add(Dense(65))
model_ensemble_nn.add(Activation('relu'))
model_ensemble_nn.add(Dropout(0.5))
model_ensemble_nn.add(Dense(num_labels))
model_ensemble_nn.add(Activation('softmax'))
model_ensemble_nn.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['acc',recall])
model_ensemble_nn.summary()
%time model_ensemble_nn.fit(train_ensem_proba,y_train,callbacks = callbacks,epochs=15000, validation_split=0.25)
model_ensemble_nn_df = print_metrics(model_ensemble_nn,train_ensem_proba,y_train,test_ensem_proba,y_test )
model_ensemble_nn_df
saveModel(model_ensemble_nn,'model_ensemble_nn')
model_ensemble_nn_df.to_csv("model_ensemble_nn_df.csv")
model_perf_train_df_names = ['model_basic_nn_df','model_basic_rnn_df','model_lstm_df',
'model_bidi_lstm_df', 'model_lstm2_df', 'model_bidi_lstm2_df']
model_perf_train_df = [model_basic_nn_df,model_basic_rnn_df,model_lstm_df,
model_bidi_lstm_df, model_lstm2_df, model_bidi_lstm2_df]
model_basic_nn_df
all_model_stats = pd.DataFrame([],columns=lb.classes_)
all_model_stats['model'] = ''
for i in zip(model_perf_train_df_names,model_perf_train_df):
i[1]['model'] = i[0]
all_model_stats = pd.concat([all_model_stats,i[1]], axis = 0)
all_model_stats
all_models_recall = pd.read_csv("all_models_recall.csv")
all_models_recall
fig, ax = plt.subplots( nrows=1, ncols=1 )
plt.bar(all_models_recall['Model Name'], all_models_recall['Number of parameters'])
plt.xticks(rotation=70)
plt.title("Number of parameters")
plt.show()